/*
 * Auto generated C++ implementation for Mass Effect 2.
 *	by _silencer.
 */

#include "stdafx.h"
#include "unreal_game.h"

namespace game
{
	IMPLEMENT_PACKAGE_CLASS( Object, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( Factory, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( TextBufferFactory, Factory, Core )
	IMPLEMENT_PACKAGE_CLASS( TextBuffer, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( Subsystem, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( System, Subsystem, Core )
	IMPLEMENT_PACKAGE_CLASS( Field, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( Property, Field, Core )
	IMPLEMENT_PACKAGE_CLASS( StructProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( StrProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( StringRefProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( Struct, Field, Core )
	IMPLEMENT_PACKAGE_CLASS( ScriptStruct, Struct, Core )
	IMPLEMENT_PACKAGE_CLASS( PackageMap, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( ObjectSerializer, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( ObjectRedirector, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( NameProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( MetaData, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( MapProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( Linker, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( LinkerSave, Linker, Core )
	IMPLEMENT_PACKAGE_CLASS( LinkerLoad, Linker, Core )
	IMPLEMENT_PACKAGE_CLASS( IntProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( InterfaceProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( Interface, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( Commandlet, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( HelpCommandlet, Commandlet, Core )
	IMPLEMENT_PACKAGE_CLASS( Function, Struct, Core )
	IMPLEMENT_PACKAGE_CLASS( FloatProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( Exporter, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( Enum, Field, Core )
	IMPLEMENT_PACKAGE_CLASS( Component, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( DistributionVector, Component, Core )
	IMPLEMENT_PACKAGE_CLASS( DistributionFloat, Component, Core )
	IMPLEMENT_PACKAGE_CLASS( DelegateProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( Const, Field, Core )
	IMPLEMENT_PACKAGE_CLASS( ObjectProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( ComponentProperty, ObjectProperty, Core )
	IMPLEMENT_PACKAGE_CLASS( ClassProperty, ObjectProperty, Core )
	IMPLEMENT_PACKAGE_CLASS( ByteProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( BoolProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( BioTelemetry, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( BioCoreBaseObject, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( BioBaseTokenParser, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( BioBaseTlkFile, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( BioBaseSaveObject, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( Package, Object, Core )
	IMPLEMENT_PACKAGE_CLASS( State, Struct, Core )
	IMPLEMENT_PACKAGE_CLASS( Class, State, Core )
	IMPLEMENT_PACKAGE_CLASS( ArrayProperty, Property, Core )
	IMPLEMENT_PACKAGE_CLASS( Default__Class, Object, Core )


	Int Object::GetNetIndex()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetNetIndex" );

		struct GetNetIndexParams
		{
			Int ReturnValue; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::appScreenDebugMessage( String sMsg )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.appScreenDebugMessage" );

		struct appScreenDebugMessageParams
		{
			String sMsg; //offset = 0, size = 12
		} params;

		params.sMsg = sMsg;

		this->call_function( function, &params, 0 );
	}

	Vector Object::TransformVectorByRotation( Rotator SourceRotation, Vector SourceVector, Bool bInverse )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.TransformVectorByRotation" );

		struct TransformVectorByRotationParams
		{
			Rotator SourceRotation; //offset = 0, size = 12
			Vector SourceVector; //offset = 12, size = 12
			Bool bInverse: 1; //offset = 24, size = 4
			Vector ReturnValue; //offset = 28, size = 12
		} params;

		params.SourceRotation = SourceRotation;
		params.SourceVector = SourceVector;
		params.bInverse = bInverse;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Name Object::GetPackageName(, Object* O )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetPackageName" );

		struct GetPackageNameParams
		{
			Name ReturnValue; //offset = 0, size = 8
			Object* O; //offset = 8, size = 4
		} params;

		params.O = O;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::IsPendingKill()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.IsPendingKill" );

		struct IsPendingKillParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::ByteToFloat( Byte inputByte, Bool bSigned )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ByteToFloat" );

		struct ByteToFloatParams
		{
			Byte inputByte; //offset = 0, size = 1
			Bool bSigned: 1; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.inputByte = inputByte;
		params.bSigned = bSigned;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::FloatToByte( Float inputFloat, Bool bSigned )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FloatToByte" );

		struct FloatToByteParams
		{
			Float inputFloat; //offset = 0, size = 4
			Bool bSigned: 1; //offset = 4, size = 4
			Byte ReturnValue; //offset = 8, size = 1
		} params;

		params.inputFloat = inputFloat;
		params.bSigned = bSigned;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::UnwindHeading( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.UnwindHeading" );

		struct UnwindHeadingParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FindDeltaAngle( Float A1, Float A2, Float Delta )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FindDeltaAngle" );

		struct FindDeltaAngleParams
		{
			Float A1; //offset = 0, size = 4
			Float A2; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
			Float Delta; //offset = 12, size = 4
		} params;

		params.A1 = A1;
		params.A2 = A2;
		params.Delta = Delta;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::GetHeadingAngle( Vector Dir, Float Angle )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetHeadingAngle" );

		struct GetHeadingAngleParams
		{
			Vector Dir; //offset = 0, size = 12
			Float ReturnValue; //offset = 12, size = 4
			Float Angle; //offset = 16, size = 4
		} params;

		params.Dir = Dir;
		params.Angle = Angle;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::GetAngularDegreesFromRadians( Vector2D OutFOV )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetAngularDegreesFromRadians" );

		struct GetAngularDegreesFromRadiansParams
		{
			Vector2D OutFOV; //offset = 0, size = 8
		} params;

		params.OutFOV = OutFOV;

		this->call_function( function, &params, 0 );
	}

	void Object::GetAngularFromDotDist( Vector2D OutAngDist, Vector2D DotDist )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetAngularFromDotDist" );

		struct GetAngularFromDotDistParams
		{
			Vector2D OutAngDist; //offset = 0, size = 8
			Vector2D DotDist; //offset = 8, size = 8
		} params;

		params.OutAngDist = OutAngDist;
		params.DotDist = DotDist;

		this->call_function( function, &params, 0 );
	}

	Bool Object::GetAngularDistance( Vector2D OutAngularDist, Vector Direction, Vector AxisX, Vector AxisY, Vector AxisZ )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetAngularDistance" );

		struct GetAngularDistanceParams
		{
			Vector2D OutAngularDist; //offset = 0, size = 8
			Vector Direction; //offset = 8, size = 12
			Vector AxisX; //offset = 20, size = 12
			Vector AxisY; //offset = 32, size = 12
			Vector AxisZ; //offset = 44, size = 12
			Bool ReturnValue: 1; //offset = 56, size = 4
		} params;

		params.OutAngularDist = OutAngularDist;
		params.Direction = Direction;
		params.AxisX = AxisX;
		params.AxisY = AxisY;
		params.AxisZ = AxisZ;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::GetDotDistance( Vector2D OutDotDist, Vector Direction, Vector AxisX, Vector AxisY, Vector AxisZ )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetDotDistance" );

		struct GetDotDistanceParams
		{
			Vector2D OutDotDist; //offset = 0, size = 8
			Vector Direction; //offset = 8, size = 12
			Vector AxisX; //offset = 20, size = 12
			Vector AxisY; //offset = 32, size = 12
			Vector AxisZ; //offset = 44, size = 12
			Bool ReturnValue: 1; //offset = 56, size = 4
		} params;

		params.OutDotDist = OutDotDist;
		params.Direction = Direction;
		params.AxisX = AxisX;
		params.AxisY = AxisY;
		params.AxisZ = AxisZ;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::PointInBox( Vector Point, Vector Location, Vector Extent, Vector MinBox, Vector MaxBox )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PointInBox" );

		struct PointInBoxParams
		{
			Vector Point; //offset = 0, size = 12
			Vector Location; //offset = 12, size = 12
			Vector Extent; //offset = 24, size = 12
			Bool ReturnValue: 1; //offset = 36, size = 4
			Vector MinBox; //offset = 40, size = 12
			Vector MaxBox; //offset = 52, size = 12
		} params;

		params.Point = Point;
		params.Location = Location;
		params.Extent = Extent;
		params.MinBox = MinBox;
		params.MaxBox = MaxBox;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::PointDistToPlane( Vector Point, Rotator Orientation, Vector Origin, Vector out_ClosestPoint, Vector AxisX, Vector AxisY, Vector AxisZ, Vector PointNoZ, Vector OriginNoZ, Float fPointZ, Float fProjDistToAxis )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PointDistToPlane" );

		struct PointDistToPlaneParams
		{
			Vector Point; //offset = 0, size = 12
			Rotator Orientation; //offset = 12, size = 12
			Vector Origin; //offset = 24, size = 12
			Vector out_ClosestPoint; //offset = 36, size = 12
			Float ReturnValue; //offset = 48, size = 4
			Vector AxisX; //offset = 52, size = 12
			Vector AxisY; //offset = 64, size = 12
			Vector AxisZ; //offset = 76, size = 12
			Vector PointNoZ; //offset = 88, size = 12
			Vector OriginNoZ; //offset = 100, size = 12
			Float fPointZ; //offset = 112, size = 4
			Float fProjDistToAxis; //offset = 116, size = 4
		} params;

		params.Point = Point;
		params.Orientation = Orientation;
		params.Origin = Origin;
		params.out_ClosestPoint = out_ClosestPoint;
		params.AxisX = AxisX;
		params.AxisY = AxisY;
		params.AxisZ = AxisZ;
		params.PointNoZ = PointNoZ;
		params.OriginNoZ = OriginNoZ;
		params.fPointZ = fPointZ;
		params.fProjDistToAxis = fProjDistToAxis;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::PointDistToLine( Vector Point, Vector Line, Vector Origin, Vector OutClosestPoint )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PointDistToLine" );

		struct PointDistToLineParams
		{
			Vector Point; //offset = 0, size = 12
			Vector Line; //offset = 12, size = 12
			Vector Origin; //offset = 24, size = 12
			Vector OutClosestPoint; //offset = 36, size = 12
			Float ReturnValue; //offset = 48, size = 4
		} params;

		params.Point = Point;
		params.Line = Line;
		params.Origin = Origin;
		params.OutClosestPoint = OutClosestPoint;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::GetPerObjectConfigSections( Class* SearchClass, Array<String> out_SectionNames, Object* ObjectOuter, Int MaxResults )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetPerObjectConfigSections" );

		struct GetPerObjectConfigSectionsParams
		{
			Class* SearchClass; //offset = 0, size = 4
			Array<String> out_SectionNames; //offset = 4, size = 12
			Object* ObjectOuter; //offset = 16, size = 4
			Int MaxResults; //offset = 20, size = 4
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.SearchClass = SearchClass;
		params.out_SectionNames = out_SectionNames;
		params.ObjectOuter = ObjectOuter;
		params.MaxResults = MaxResults;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::StaticSaveConfig()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.StaticSaveConfig" );

		this->call_function( function, 0, 0 );
	}

	void Object::SaveConfig()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SaveConfig" );

		this->call_function( function, 0, 0 );
	}

	Object* Object::FindObject( String ObjectName, Class* ObjectClass )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FindObject" );

		struct FindObjectParams
		{
			String ObjectName; //offset = 0, size = 12
			Class* ObjectClass; //offset = 12, size = 4
			Object* ReturnValue; //offset = 16, size = 4
		} params;

		params.ObjectName = ObjectName;
		params.ObjectClass = ObjectClass;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Object* Object::DynamicLoadObject( String ObjectName, Class* ObjectClass, Bool MayFail )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DynamicLoadObject" );

		struct DynamicLoadObjectParams
		{
			String ObjectName; //offset = 0, size = 12
			Class* ObjectClass; //offset = 12, size = 4
			Bool MayFail: 1; //offset = 16, size = 4
			Object* ReturnValue; //offset = 20, size = 4
		} params;

		params.ObjectName = ObjectName;
		params.ObjectClass = ObjectClass;
		params.MayFail = MayFail;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::GetEnumIndex( Object* E, Name valuename )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetEnumIndex" );

		struct GetEnumIndexParams
		{
			Object* E; //offset = 0, size = 4
			Name valuename; //offset = 4, size = 8
			Int ReturnValue; //offset = 12, size = 4
		} params;

		params.E = E;
		params.valuename = valuename;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Name Object::GetEnum( Object* E, Int I )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetEnum" );

		struct GetEnumParams
		{
			Object* E; //offset = 0, size = 4
			Int I; //offset = 4, size = 4
			Name ReturnValue; //offset = 8, size = 8
		} params;

		params.E = E;
		params.I = I;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::Disable( Name ProbeFunc )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Disable" );

		struct DisableParams
		{
			Name ProbeFunc; //offset = 0, size = 8
		} params;

		params.ProbeFunc = ProbeFunc;

		this->call_function( function, &params, 0 );
	}

	void Object::Enable( Name ProbeFunc )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Enable" );

		struct EnableParams
		{
			Name ProbeFunc; //offset = 0, size = 8
		} params;

		params.ProbeFunc = ProbeFunc;

		this->call_function( function, &params, 0 );
	}

	void Object::ContinuedState()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ContinuedState" );

		this->call_function( function, 0, 0 );
	}

	void Object::PausedState()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PausedState" );

		this->call_function( function, 0, 0 );
	}

	void Object::PoppedState()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PoppedState" );

		this->call_function( function, 0, 0 );
	}

	void Object::PushedState()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PushedState" );

		this->call_function( function, 0, 0 );
	}

	void Object::EndState( Name NextStateName )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EndState" );

		struct EndStateParams
		{
			Name NextStateName; //offset = 0, size = 8
		} params;

		params.NextStateName = NextStateName;

		this->call_function( function, &params, 0 );
	}

	void Object::BeginState( Name PreviousStateName )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.BeginState" );

		struct BeginStateParams
		{
			Name PreviousStateName; //offset = 0, size = 8
		} params;

		params.PreviousStateName = PreviousStateName;

		this->call_function( function, &params, 0 );
	}

	void Object::DumpStateStack()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DumpStateStack" );

		this->call_function( function, 0, 0 );
	}

	void Object::PopState( Bool bPopAll )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PopState" );

		struct PopStateParams
		{
			Bool bPopAll: 1; //offset = 0, size = 4
		} params;

		params.bPopAll = bPopAll;

		this->call_function( function, &params, 0 );
	}

	void Object::PushState( Name NewState, Name NewLabel )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PushState" );

		struct PushStateParams
		{
			Name NewState; //offset = 0, size = 8
			Name NewLabel; //offset = 8, size = 8
		} params;

		params.NewState = NewState;
		params.NewLabel = NewLabel;

		this->call_function( function, &params, 0 );
	}

	Name Object::GetStateName()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetStateName" );

		struct GetStateNameParams
		{
			Name ReturnValue; //offset = 0, size = 8
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::IsChildState( Name TestState, Name TestParentState )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.IsChildState" );

		struct IsChildStateParams
		{
			Name TestState; //offset = 0, size = 8
			Name TestParentState; //offset = 8, size = 8
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.TestState = TestState;
		params.TestParentState = TestParentState;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::IsInState( Name TestState, Bool bTestStateStack )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.IsInState" );

		struct IsInStateParams
		{
			Name TestState; //offset = 0, size = 8
			Bool bTestStateStack: 1; //offset = 8, size = 4
			Bool ReturnValue: 1; //offset = 12, size = 4
		} params;

		params.TestState = TestState;
		params.bTestStateStack = bTestStateStack;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::GotoState( Name NewState, Name Label, Bool bForceEvents, Bool bKeepStack )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GotoState" );

		struct GotoStateParams
		{
			Name NewState; //offset = 0, size = 8
			Name Label; //offset = 8, size = 8
			Bool bForceEvents: 1; //offset = 16, size = 4
			Bool bKeepStack: 1; //offset = 20, size = 4
		} params;

		params.NewState = NewState;
		params.Label = Label;
		params.bForceEvents = bForceEvents;
		params.bKeepStack = bKeepStack;

		this->call_function( function, &params, 0 );
	}

	void Object::ReadSaveObject( BioBaseSaveObject* Save )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ReadSaveObject" );

		struct ReadSaveObjectParams
		{
			BioBaseSaveObject* Save; //offset = 0, size = 4
		} params;

		params.Save = Save;

		this->call_function( function, &params, 0 );
	}

	BioBaseSaveObject* Object::WriteSaveObject( Object* InOuter, BioBaseSaveObject* Save, Class* SaveClass )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.WriteSaveObject" );

		struct WriteSaveObjectParams
		{
			Object* InOuter; //offset = 0, size = 4
			BioBaseSaveObject* Save; //offset = 4, size = 4
			BioBaseSaveObject* ReturnValue; //offset = 8, size = 4
			Class* SaveClass; //offset = 12, size = 4
		} params;

		params.InOuter = InOuter;
		params.Save = Save;
		params.SaveClass = SaveClass;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Class* Object::GetSaveObjectClass()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetSaveObjectClass" );

		struct GetSaveObjectClassParams
		{
			Class* ReturnValue; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::CopyToSaveObject( BioBaseSaveObject* Save )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.CopyToSaveObject" );

		struct CopyToSaveObjectParams
		{
			BioBaseSaveObject* Save; //offset = 0, size = 4
		} params;

		params.Save = Save;

		this->call_function( function, &params, 0 );
	}

	void Object::CopyFromSaveObject( BioBaseSaveObject* Save )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.CopyFromSaveObject" );

		struct CopyFromSaveObjectParams
		{
			BioBaseSaveObject* Save; //offset = 0, size = 4
		} params;

		params.Save = Save;

		this->call_function( function, &params, 0 );
	}

	Object* Object::BioDuplicate( Object* DupObject, Object* InOuter )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.BioDuplicate" );

		struct BioDuplicateParams
		{
			Object* DupObject; //offset = 0, size = 4
			Object* InOuter; //offset = 4, size = 4
			Object* ReturnValue; //offset = 8, size = 4
		} params;

		params.DupObject = DupObject;
		params.InOuter = InOuter;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::IsUTracing()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.IsUTracing" );

		struct IsUTracingParams
		{
			Bool ReturnValue: 1; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::SetUTracing( Bool bShouldUTrace )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SetUTracing" );

		struct SetUTracingParams
		{
			Bool bShouldUTrace: 1; //offset = 0, size = 4
		} params;

		params.bShouldUTrace = bShouldUTrace;

		this->call_function( function, &params, 0 );
	}

	Name Object::GetFuncName()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetFuncName" );

		struct GetFuncNameParams
		{
			Name ReturnValue; //offset = 0, size = 8
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::ScriptTrace()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ScriptTrace" );

		this->call_function( function, 0, 0 );
	}

	String Object::Localize( String SectionName, String KeyName, String PackageName )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Localize" );

		struct LocalizeParams
		{
			String SectionName; //offset = 0, size = 12
			String KeyName; //offset = 12, size = 12
			String PackageName; //offset = 24, size = 12
			String ReturnValue; //offset = 36, size = 12
		} params;

		params.SectionName = SectionName;
		params.KeyName = KeyName;
		params.PackageName = PackageName;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::WarnInternal( String S )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.WarnInternal" );

		struct WarnInternalParams
		{
			String S; //offset = 0, size = 12
		} params;

		params.S = S;

		this->call_function( function, &params, 0 );
	}

	void Object::LogInternal( String S, Name Tag )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.LogInternal" );

		struct LogInternalParams
		{
			String S; //offset = 0, size = 12
			Name Tag; //offset = 12, size = 8
		} params;

		params.S = S;
		params.Tag = Tag;

		this->call_function( function, &params, 0 );
	}

	LinearColor Object::Subtract_LinearColorLinearColor( LinearColor A, LinearColor B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_LinearColorLinearColor" );

		struct Subtract_LinearColorLinearColorParams
		{
			LinearColor A; //offset = 0, size = 16
			LinearColor B; //offset = 16, size = 16
			LinearColor ReturnValue; //offset = 32, size = 16
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	LinearColor Object::Multiply_LinearColorFloat( LinearColor LC, Float Mult )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_LinearColorFloat" );

		struct Multiply_LinearColorFloatParams
		{
			LinearColor LC; //offset = 0, size = 16
			Float Mult; //offset = 16, size = 4
			LinearColor ReturnValue; //offset = 20, size = 16
		} params;

		params.LC = LC;
		params.Mult = Mult;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	LinearColor Object::ColorToLinearColor( Color OldColor )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ColorToLinearColor" );

		struct ColorToLinearColorParams
		{
			Color OldColor; //offset = 0, size = 4
			LinearColor ReturnValue; //offset = 4, size = 16
		} params;

		params.OldColor = OldColor;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	LinearColor Object::MakeLinearColor( Float R, Float G, Float B, Float A, LinearColor LC )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MakeLinearColor" );

		struct MakeLinearColorParams
		{
			Float R; //offset = 0, size = 4
			Float G; //offset = 4, size = 4
			Float B; //offset = 8, size = 4
			Float A; //offset = 12, size = 4
			LinearColor ReturnValue; //offset = 16, size = 16
			LinearColor LC; //offset = 32, size = 16
		} params;

		params.R = R;
		params.G = G;
		params.B = B;
		params.A = A;
		params.LC = LC;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Color Object::MakeColor( Byte R, Byte G, Byte B, Byte A, Color C )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MakeColor" );

		struct MakeColorParams
		{
			Byte R; //offset = 0, size = 1
			Byte G; //offset = 1, size = 1
			Byte B; //offset = 2, size = 1
			Byte A; //offset = 3, size = 1
			Color ReturnValue; //offset = 4, size = 4
			Color C; //offset = 8, size = 4
		} params;

		params.R = R;
		params.G = G;
		params.B = B;
		params.A = A;
		params.C = C;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Color Object::Add_ColorColor( Color A, Color B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Add_ColorColor" );

		struct Add_ColorColorParams
		{
			Color A; //offset = 0, size = 4
			Color B; //offset = 4, size = 4
			Color ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Color Object::Multiply_ColorFloat( Color A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_ColorFloat" );

		struct Multiply_ColorFloatParams
		{
			Color A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Color ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Color Object::Multiply_FloatColor( Float A, Color B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_FloatColor" );

		struct Multiply_FloatColorParams
		{
			Float A; //offset = 0, size = 4
			Color B; //offset = 4, size = 4
			Color ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Color Object::Subtract_ColorColor( Color A, Color B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_ColorColor" );

		struct Subtract_ColorColorParams
		{
			Color A; //offset = 0, size = 4
			Color B; //offset = 4, size = 4
			Color ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector2D Object::vect2d( Float InX, Float InY, Vector2D NewVect2d )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.vect2d" );

		struct vect2dParams
		{
			Float InX; //offset = 0, size = 4
			Float InY; //offset = 4, size = 4
			Vector2D ReturnValue; //offset = 8, size = 8
			Vector2D NewVect2d; //offset = 16, size = 8
		} params;

		params.InX = InX;
		params.InY = InY;
		params.NewVect2d = NewVect2d;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::GetRangePctByValue( Vector2D Range, Float Value )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetRangePctByValue" );

		struct GetRangePctByValueParams
		{
			Vector2D Range; //offset = 0, size = 8
			Float Value; //offset = 8, size = 4
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.Range = Range;
		params.Value = Value;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::GetRangeValueByPct( Vector2D Range, Float Pct )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetRangeValueByPct" );

		struct GetRangeValueByPctParams
		{
			Vector2D Range; //offset = 0, size = 8
			Float Pct; //offset = 8, size = 4
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.Range = Range;
		params.Pct = Pct;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::GetVectorAboveBelow( Vector A, Vector B, Vector PlaneNormal )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetVectorAboveBelow" );

		struct GetVectorAboveBelowParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector PlaneNormal; //offset = 24, size = 12
			Int ReturnValue; //offset = 36, size = 4
		} params;

		params.A = A;
		params.B = B;
		params.PlaneNormal = PlaneNormal;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::GetVectorSide( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetVectorSide" );

		struct GetVectorSideParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Int ReturnValue; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::GetAngleBetween( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetAngleBetween" );

		struct GetAngleBetweenParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Float ReturnValue; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_IntStringRef( Int A, B B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_IntStringRef" );

		struct NotEqual_IntStringRefParams
		{
			Int A; //offset = 0, size = 4
			B B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_StringRefInt( A A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_StringRefInt" );

		struct NotEqual_StringRefIntParams
		{
			A A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_StringRefStringRef( A A, B B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_StringRefStringRef" );

		struct NotEqual_StringRefStringRefParams
		{
			A A; //offset = 0, size = 4
			B B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_IntStringRef( Int A, B B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_IntStringRef" );

		struct EqualEqual_IntStringRefParams
		{
			Int A; //offset = 0, size = 4
			B B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_StringRefInt( A A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_StringRefInt" );

		struct EqualEqual_StringRefIntParams
		{
			A A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_StringRefStringRef( A A, B B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_StringRefStringRef" );

		struct EqualEqual_StringRefStringRefParams
		{
			A A; //offset = 0, size = 4
			B B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::Subtract_QuatQuat( Quat A, Quat B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_QuatQuat" );

		struct Subtract_QuatQuatParams
		{
			Quat A; //offset = 0, size = 16
			Quat B; //offset = 16, size = 16
			Quat ReturnValue; //offset = 32, size = 16
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::Add_QuatQuat( Quat A, Quat B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Add_QuatQuat" );

		struct Add_QuatQuatParams
		{
			Quat A; //offset = 0, size = 16
			Quat B; //offset = 16, size = 16
			Quat ReturnValue; //offset = 32, size = 16
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::QuatSlerp( Quat A, Quat B, Float Alpha, Bool bShortestPath )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatSlerp" );

		struct QuatSlerpParams
		{
			Quat A; //offset = 0, size = 16
			Quat B; //offset = 16, size = 16
			Float Alpha; //offset = 32, size = 4
			Bool bShortestPath: 1; //offset = 36, size = 4
			Quat ReturnValue; //offset = 40, size = 16
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;
		params.bShortestPath = bShortestPath;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::QuatToRotator( Quat A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatToRotator" );

		struct QuatToRotatorParams
		{
			Quat A; //offset = 0, size = 16
			Rotator ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::QuatFromRotator( Rotator A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatFromRotator" );

		struct QuatFromRotatorParams
		{
			Rotator A; //offset = 0, size = 12
			Quat ReturnValue; //offset = 12, size = 16
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::QuatFromAxisAndAngle( Vector Axis, Float Angle )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatFromAxisAndAngle" );

		struct QuatFromAxisAndAngleParams
		{
			Vector Axis; //offset = 0, size = 12
			Float Angle; //offset = 12, size = 4
			Quat ReturnValue; //offset = 16, size = 16
		} params;

		params.Axis = Axis;
		params.Angle = Angle;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::QuatFindBetween( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatFindBetween" );

		struct QuatFindBetweenParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Quat ReturnValue; //offset = 24, size = 16
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::QuatRotateVector( Quat A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatRotateVector" );

		struct QuatRotateVectorParams
		{
			Quat A; //offset = 0, size = 16
			Vector B; //offset = 16, size = 12
			Vector ReturnValue; //offset = 28, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::QuatInvert( Quat A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatInvert" );

		struct QuatInvertParams
		{
			Quat A; //offset = 0, size = 16
			Quat ReturnValue; //offset = 16, size = 16
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::QuatDot( Quat A, Quat B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatDot" );

		struct QuatDotParams
		{
			Quat A; //offset = 0, size = 16
			Quat B; //offset = 16, size = 16
			Float ReturnValue; //offset = 32, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Quat Object::QuatProduct( Quat A, Quat B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.QuatProduct" );

		struct QuatProductParams
		{
			Quat A; //offset = 0, size = 16
			Quat B; //offset = 16, size = 16
			Quat ReturnValue; //offset = 32, size = 16
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_NameName( Name A, Name B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_NameName" );

		struct NotEqual_NameNameParams
		{
			Name A; //offset = 0, size = 8
			Name B; //offset = 8, size = 8
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_NameName( Name A, Name B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_NameName" );

		struct EqualEqual_NameNameParams
		{
			Name A; //offset = 0, size = 8
			Name B; //offset = 8, size = 8
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::IsA( Name ClassName )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.IsA" );

		struct IsAParams
		{
			Name ClassName; //offset = 0, size = 8
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.ClassName = ClassName;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::ClassIsChildOf( Class* TestClass, Class* ParentClass )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ClassIsChildOf" );

		struct ClassIsChildOfParams
		{
			Class* TestClass; //offset = 0, size = 4
			Class* ParentClass; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.TestClass = TestClass;
		params.ParentClass = ParentClass;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_InterfaceInterface( A A, B B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_InterfaceInterface" );

		struct NotEqual_InterfaceInterfaceParams
		{
			A A; //offset = 0, size = 8
			B B; //offset = 8, size = 8
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_InterfaceInterface( A A, B B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_InterfaceInterface" );

		struct EqualEqual_InterfaceInterfaceParams
		{
			A A; //offset = 0, size = 8
			B B; //offset = 8, size = 8
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_ObjectObject( Object* A, Object* B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_ObjectObject" );

		struct NotEqual_ObjectObjectParams
		{
			Object* A; //offset = 0, size = 4
			Object* B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_ObjectObject( Object* A, Object* B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_ObjectObject" );

		struct EqualEqual_ObjectObjectParams
		{
			Object* A; //offset = 0, size = 4
			Object* B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::PathName( Object* CheckObject )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.PathName" );

		struct PathNameParams
		{
			Object* CheckObject; //offset = 0, size = 4
			String ReturnValue; //offset = 4, size = 12
		} params;

		params.CheckObject = CheckObject;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::ParseStringIntoArray( String BaseString, Array<String> Pieces, String delim, Bool bCullEmpty )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ParseStringIntoArray" );

		struct ParseStringIntoArrayParams
		{
			String BaseString; //offset = 0, size = 12
			Array<String> Pieces; //offset = 12, size = 12
			String delim; //offset = 24, size = 12
			Bool bCullEmpty: 1; //offset = 36, size = 4
		} params;

		params.BaseString = BaseString;
		params.Pieces = Pieces;
		params.delim = delim;
		params.bCullEmpty = bCullEmpty;

		this->call_function( function, &params, 0 );
	}

	void Object::JoinArray( Array<String> StringArray, String out_Result, String delim, Bool bIgnoreBlanks, Int I )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.JoinArray" );

		struct JoinArrayParams
		{
			Array<String> StringArray; //offset = 0, size = 12
			String out_Result; //offset = 12, size = 12
			String delim; //offset = 24, size = 12
			Bool bIgnoreBlanks: 1; //offset = 36, size = 4
			Int I; //offset = 40, size = 4
		} params;

		params.StringArray = StringArray;
		params.out_Result = out_Result;
		params.delim = delim;
		params.bIgnoreBlanks = bIgnoreBlanks;
		params.I = I;

		this->call_function( function, &params, 0 );
	}

	String Object::GetRightMost( String Text, Int strIdx )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetRightMost" );

		struct GetRightMostParams
		{
			String Text; //offset = 0, size = 12
			String ReturnValue; //offset = 12, size = 12
			Int strIdx; //offset = 24, size = 4
		} params;

		params.Text = Text;
		params.strIdx = strIdx;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Split( String Text, String SplitStr, Bool bOmitSplitStr, Int pos )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Split" );

		struct SplitParams
		{
			String Text; //offset = 0, size = 12
			String SplitStr; //offset = 12, size = 12
			Bool bOmitSplitStr: 1; //offset = 24, size = 4
			String ReturnValue; //offset = 28, size = 12
			Int pos; //offset = 40, size = 4
		} params;

		params.Text = Text;
		params.SplitStr = SplitStr;
		params.bOmitSplitStr = bOmitSplitStr;
		params.pos = pos;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Repl( String Src, String Match, String With, Bool bCaseSensitive )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Repl" );

		struct ReplParams
		{
			String Src; //offset = 0, size = 12
			String Match; //offset = 12, size = 12
			String With; //offset = 24, size = 12
			Bool bCaseSensitive: 1; //offset = 36, size = 4
			String ReturnValue; //offset = 40, size = 12
		} params;

		params.Src = Src;
		params.Match = Match;
		params.With = With;
		params.bCaseSensitive = bCaseSensitive;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Asc( String S )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Asc" );

		struct AscParams
		{
			String S; //offset = 0, size = 12
			Int ReturnValue; //offset = 12, size = 4
		} params;

		params.S = S;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Chr( Int I )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Chr" );

		struct ChrParams
		{
			Int I; //offset = 0, size = 4
			String ReturnValue; //offset = 4, size = 12
		} params;

		params.I = I;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Locs( String S )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Locs" );

		struct LocsParams
		{
			String S; //offset = 0, size = 12
			String ReturnValue; //offset = 12, size = 12
		} params;

		params.S = S;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Caps( String S )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Caps" );

		struct CapsParams
		{
			String S; //offset = 0, size = 12
			String ReturnValue; //offset = 12, size = 12
		} params;

		params.S = S;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Right( String S, Int I )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Right" );

		struct RightParams
		{
			String S; //offset = 0, size = 12
			Int I; //offset = 12, size = 4
			String ReturnValue; //offset = 16, size = 12
		} params;

		params.S = S;
		params.I = I;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Left( String S, Int I )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Left" );

		struct LeftParams
		{
			String S; //offset = 0, size = 12
			Int I; //offset = 12, size = 4
			String ReturnValue; //offset = 16, size = 12
		} params;

		params.S = S;
		params.I = I;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Mid( String S, Int I, Int J )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Mid" );

		struct MidParams
		{
			String S; //offset = 0, size = 12
			Int I; //offset = 12, size = 4
			Int J; //offset = 16, size = 4
			String ReturnValue; //offset = 20, size = 12
		} params;

		params.S = S;
		params.I = I;
		params.J = J;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::InStr( String S, String T, Bool bSearchFromRight )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.InStr" );

		struct InStrParams
		{
			String S; //offset = 0, size = 12
			String T; //offset = 12, size = 12
			Bool bSearchFromRight: 1; //offset = 24, size = 4
			Int ReturnValue; //offset = 28, size = 4
		} params;

		params.S = S;
		params.T = T;
		params.bSearchFromRight = bSearchFromRight;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Len( String S )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Len" );

		struct LenParams
		{
			String S; //offset = 0, size = 12
			Int ReturnValue; //offset = 12, size = 4
		} params;

		params.S = S;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::SubtractEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractEqual_StrStr" );

		struct SubtractEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			String ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::AtEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AtEqual_StrStr" );

		struct AtEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			String ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::ConcatEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ConcatEqual_StrStr" );

		struct ConcatEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			String ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::ComplementEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ComplementEqual_StrStr" );

		struct ComplementEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_StrStr" );

		struct NotEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_StrStr" );

		struct EqualEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::GreaterEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GreaterEqual_StrStr" );

		struct GreaterEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::LessEqual_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.LessEqual_StrStr" );

		struct LessEqual_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::Greater_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Greater_StrStr" );

		struct Greater_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::Less_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Less_StrStr" );

		struct Less_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::At_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.At_StrStr" );

		struct At_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			String ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::Concat_StrStr( String A, String B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Concat_StrStr" );

		struct Concat_StrStrParams
		{
			String A; //offset = 0, size = 12
			String B; //offset = 12, size = 12
			String ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::SClampRotAxis( Float DeltaTime, Int ViewAxis, Int out_DeltaViewAxis, Int MaxLimit, Int MinLimit, Float InterpolationSpeed, Bool bClamped )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SClampRotAxis" );

		struct SClampRotAxisParams
		{
			Float DeltaTime; //offset = 0, size = 4
			Int ViewAxis; //offset = 4, size = 4
			Int out_DeltaViewAxis; //offset = 8, size = 4
			Int MaxLimit; //offset = 12, size = 4
			Int MinLimit; //offset = 16, size = 4
			Float InterpolationSpeed; //offset = 20, size = 4
			Bool ReturnValue: 1; //offset = 24, size = 4
			Bool bClamped: 1; //offset = 28, size = 4
		} params;

		params.DeltaTime = DeltaTime;
		params.ViewAxis = ViewAxis;
		params.out_DeltaViewAxis = out_DeltaViewAxis;
		params.MaxLimit = MaxLimit;
		params.MinLimit = MinLimit;
		params.InterpolationSpeed = InterpolationSpeed;
		params.bClamped = bClamped;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::ClampRotAxisFromBase( Int Current, Int Center, Int MaxDelta, Int DeltaFromCenter )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ClampRotAxisFromBase" );

		struct ClampRotAxisFromBaseParams
		{
			Int Current; //offset = 0, size = 4
			Int Center; //offset = 4, size = 4
			Int MaxDelta; //offset = 8, size = 4
			Int ReturnValue; //offset = 12, size = 4
			Int DeltaFromCenter; //offset = 16, size = 4
		} params;

		params.Current = Current;
		params.Center = Center;
		params.MaxDelta = MaxDelta;
		params.DeltaFromCenter = DeltaFromCenter;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::ClampRotAxis( Int ViewAxis, Int out_DeltaViewAxis, Int MaxLimit, Int MinLimit, Int DesiredViewAxis )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ClampRotAxis" );

		struct ClampRotAxisParams
		{
			Int ViewAxis; //offset = 0, size = 4
			Int out_DeltaViewAxis; //offset = 4, size = 4
			Int MaxLimit; //offset = 8, size = 4
			Int MinLimit; //offset = 12, size = 4
			Int DesiredViewAxis; //offset = 16, size = 4
		} params;

		params.ViewAxis = ViewAxis;
		params.out_DeltaViewAxis = out_DeltaViewAxis;
		params.MaxLimit = MaxLimit;
		params.MinLimit = MinLimit;
		params.DesiredViewAxis = DesiredViewAxis;

		this->call_function( function, &params, 0 );
	}

	Float Object::RSize( Rotator R, Int PitchNorm, Int YawNorm, Int RollNorm )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.RSize" );

		struct RSizeParams
		{
			Rotator R; //offset = 0, size = 12
			Float ReturnValue; //offset = 12, size = 4
			Int PitchNorm; //offset = 16, size = 4
			Int YawNorm; //offset = 20, size = 4
			Int RollNorm; //offset = 24, size = 4
		} params;

		params.R = R;
		params.PitchNorm = PitchNorm;
		params.YawNorm = YawNorm;
		params.RollNorm = RollNorm;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::RDiff( Rotator A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.RDiff" );

		struct RDiffParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Float ReturnValue; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::NormalizeRotAxis( Int Angle )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NormalizeRotAxis" );

		struct NormalizeRotAxisParams
		{
			Int Angle; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.Angle = Angle;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::RInterpTo( Rotator Current, Rotator Target, Float DeltaTime, Float InterpSpeed )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.RInterpTo" );

		struct RInterpToParams
		{
			Rotator Current; //offset = 0, size = 12
			Rotator Target; //offset = 12, size = 12
			Float DeltaTime; //offset = 24, size = 4
			Float InterpSpeed; //offset = 28, size = 4
			Rotator ReturnValue; //offset = 32, size = 12
		} params;

		params.Current = Current;
		params.Target = Target;
		params.DeltaTime = DeltaTime;
		params.InterpSpeed = InterpSpeed;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::RSmerp( Rotator A, Rotator B, Float Alpha, Bool bShortestPath )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.RSmerp" );

		struct RSmerpParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Float Alpha; //offset = 24, size = 4
			Bool bShortestPath: 1; //offset = 28, size = 4
			Rotator ReturnValue; //offset = 32, size = 12
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;
		params.bShortestPath = bShortestPath;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::RLerp( Rotator A, Rotator B, Float Alpha, Bool bShortestPath )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.RLerp" );

		struct RLerpParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Float Alpha; //offset = 24, size = 4
			Bool bShortestPath: 1; //offset = 28, size = 4
			Rotator ReturnValue; //offset = 32, size = 12
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;
		params.bShortestPath = bShortestPath;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::Normalize( Rotator Rot )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Normalize" );

		struct NormalizeParams
		{
			Rotator Rot; //offset = 0, size = 12
			Rotator ReturnValue; //offset = 12, size = 12
		} params;

		params.Rot = Rot;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::OrthoRotation( Vector X, Vector Y, Vector Z )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.OrthoRotation" );

		struct OrthoRotationParams
		{
			Vector X; //offset = 0, size = 12
			Vector Y; //offset = 12, size = 12
			Vector Z; //offset = 24, size = 12
			Rotator ReturnValue; //offset = 36, size = 12
		} params;

		params.X = X;
		params.Y = Y;
		params.Z = Z;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::RotRand( Bool bRoll )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.RotRand" );

		struct RotRandParams
		{
			Bool bRoll: 1; //offset = 0, size = 4
			Rotator ReturnValue; //offset = 4, size = 12
		} params;

		params.bRoll = bRoll;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::GetUnAxes( Rotator A, Vector X, Vector Y, Vector Z )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetUnAxes" );

		struct GetUnAxesParams
		{
			Rotator A; //offset = 0, size = 12
			Vector X; //offset = 12, size = 12
			Vector Y; //offset = 24, size = 12
			Vector Z; //offset = 36, size = 12
		} params;

		params.A = A;
		params.X = X;
		params.Y = Y;
		params.Z = Z;

		this->call_function( function, &params, 0 );
	}

	void Object::GetAxes( Rotator A, Vector X, Vector Y, Vector Z )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetAxes" );

		struct GetAxesParams
		{
			Rotator A; //offset = 0, size = 12
			Vector X; //offset = 12, size = 12
			Vector Y; //offset = 24, size = 12
			Vector Z; //offset = 36, size = 12
		} params;

		params.A = A;
		params.X = X;
		params.Y = Y;
		params.Z = Z;

		this->call_function( function, &params, 0 );
	}

	Bool Object::ClockwiseFrom_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ClockwiseFrom_IntInt" );

		struct ClockwiseFrom_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::SubtractEqual_RotatorRotator( Rotator A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractEqual_RotatorRotator" );

		struct SubtractEqual_RotatorRotatorParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Rotator ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::AddEqual_RotatorRotator( Rotator A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddEqual_RotatorRotator" );

		struct AddEqual_RotatorRotatorParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Rotator ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::Subtract_RotatorRotator( Rotator A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_RotatorRotator" );

		struct Subtract_RotatorRotatorParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Rotator ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::Add_RotatorRotator( Rotator A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Add_RotatorRotator" );

		struct Add_RotatorRotatorParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Rotator ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::DivideEqual_RotatorFloat( Rotator A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DivideEqual_RotatorFloat" );

		struct DivideEqual_RotatorFloatParams
		{
			Rotator A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Rotator ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::MultiplyEqual_RotatorFloat( Rotator A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyEqual_RotatorFloat" );

		struct MultiplyEqual_RotatorFloatParams
		{
			Rotator A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Rotator ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::Divide_RotatorFloat( Rotator A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Divide_RotatorFloat" );

		struct Divide_RotatorFloatParams
		{
			Rotator A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Rotator ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::Multiply_FloatRotator( Float A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_FloatRotator" );

		struct Multiply_FloatRotatorParams
		{
			Float A; //offset = 0, size = 4
			Rotator B; //offset = 4, size = 12
			Rotator ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Rotator Object::Multiply_RotatorFloat( Rotator A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_RotatorFloat" );

		struct Multiply_RotatorFloatParams
		{
			Rotator A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Rotator ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_RotatorRotator( Rotator A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_RotatorRotator" );

		struct NotEqual_RotatorRotatorParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_RotatorRotator( Rotator A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_RotatorRotator" );

		struct EqualEqual_RotatorRotatorParams
		{
			Rotator A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::ClampLength( Vector V, Float MaxLength )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ClampLength" );

		struct ClampLengthParams
		{
			Vector V; //offset = 0, size = 12
			Float MaxLength; //offset = 12, size = 4
			Vector ReturnValue; //offset = 16, size = 12
		} params;

		params.V = V;
		params.MaxLength = MaxLength;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::VInterpTo( Vector Current, Vector Target, Float DeltaTime, Float InterpSpeed )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VInterpTo" );

		struct VInterpToParams
		{
			Vector Current; //offset = 0, size = 12
			Vector Target; //offset = 12, size = 12
			Float DeltaTime; //offset = 24, size = 4
			Float InterpSpeed; //offset = 28, size = 4
			Vector ReturnValue; //offset = 32, size = 12
		} params;

		params.Current = Current;
		params.Target = Target;
		params.DeltaTime = DeltaTime;
		params.InterpSpeed = InterpSpeed;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::IsZero( Vector A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.IsZero" );

		struct IsZeroParams
		{
			Vector A; //offset = 0, size = 12
			Bool ReturnValue: 1; //offset = 12, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::ProjectOnTo( Vector X, Vector Y )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ProjectOnTo" );

		struct ProjectOnToParams
		{
			Vector X; //offset = 0, size = 12
			Vector Y; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.X = X;
		params.Y = Y;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::MirrorVectorByNormal( Vector InVect, Vector InNormal )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MirrorVectorByNormal" );

		struct MirrorVectorByNormalParams
		{
			Vector InVect; //offset = 0, size = 12
			Vector InNormal; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.InVect = InVect;
		params.InNormal = InNormal;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::VRand()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VRand" );

		struct VRandParams
		{
			Vector ReturnValue; //offset = 0, size = 12
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::VSmerp( Vector A, Vector B, Float Alpha )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VSmerp" );

		struct VSmerpParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Float Alpha; //offset = 24, size = 4
			Vector ReturnValue; //offset = 28, size = 12
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::VLerp( Vector A, Vector B, Float Alpha )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VLerp" );

		struct VLerpParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Float Alpha; //offset = 24, size = 4
			Vector ReturnValue; //offset = 28, size = 12
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Normal( Vector A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Normal" );

		struct NormalParams
		{
			Vector A; //offset = 0, size = 12
			Vector ReturnValue; //offset = 12, size = 12
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::VSizeSq2D( Vector A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VSizeSq2D" );

		struct VSizeSq2DParams
		{
			Vector A; //offset = 0, size = 12
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::VSizeSq( Vector A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VSizeSq" );

		struct VSizeSqParams
		{
			Vector A; //offset = 0, size = 12
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::VSize2D( Vector A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VSize2D" );

		struct VSize2DParams
		{
			Vector A; //offset = 0, size = 12
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::VSize( Vector A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.VSize" );

		struct VSizeParams
		{
			Vector A; //offset = 0, size = 12
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::SubtractEqual_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractEqual_VectorVector" );

		struct SubtractEqual_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::AddEqual_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddEqual_VectorVector" );

		struct AddEqual_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::DivideEqual_VectorFloat( Vector A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DivideEqual_VectorFloat" );

		struct DivideEqual_VectorFloatParams
		{
			Vector A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Vector ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::MultiplyEqual_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyEqual_VectorVector" );

		struct MultiplyEqual_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::MultiplyEqual_VectorFloat( Vector A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyEqual_VectorFloat" );

		struct MultiplyEqual_VectorFloatParams
		{
			Vector A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Vector ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Cross_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Cross_VectorVector" );

		struct Cross_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Dot_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Dot_VectorVector" );

		struct Dot_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Float ReturnValue; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_VectorVector" );

		struct NotEqual_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_VectorVector" );

		struct EqualEqual_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Bool ReturnValue: 1; //offset = 24, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::GreaterGreater_VectorRotator( Vector A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GreaterGreater_VectorRotator" );

		struct GreaterGreater_VectorRotatorParams
		{
			Vector A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::LessLess_VectorRotator( Vector A, Rotator B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.LessLess_VectorRotator" );

		struct LessLess_VectorRotatorParams
		{
			Vector A; //offset = 0, size = 12
			Rotator B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Subtract_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_VectorVector" );

		struct Subtract_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Add_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Add_VectorVector" );

		struct Add_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Divide_VectorFloat( Vector A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Divide_VectorFloat" );

		struct Divide_VectorFloatParams
		{
			Vector A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Vector ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Multiply_VectorVector( Vector A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_VectorVector" );

		struct Multiply_VectorVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector B; //offset = 12, size = 12
			Vector ReturnValue; //offset = 24, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Multiply_FloatVector( Float A, Vector B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_FloatVector" );

		struct Multiply_FloatVectorParams
		{
			Float A; //offset = 0, size = 4
			Vector B; //offset = 4, size = 12
			Vector ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Multiply_VectorFloat( Vector A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_VectorFloat" );

		struct Multiply_VectorFloatParams
		{
			Vector A; //offset = 0, size = 12
			Float B; //offset = 12, size = 4
			Vector ReturnValue; //offset = 16, size = 12
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Vector Object::Subtract_PreVector( Vector A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_PreVector" );

		struct Subtract_PreVectorParams
		{
			Vector A; //offset = 0, size = 12
			Vector ReturnValue; //offset = 12, size = 12
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::GetTokenisedString( Int srStringID, Array<SFXTokenMapping> TokenList )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GetTokenisedString" );

		struct GetTokenisedStringParams
		{
			Int srStringID; //offset = 0, size = 4
			Array<SFXTokenMapping> TokenList; //offset = 4, size = 12
			String ReturnValue; //offset = 16, size = 12
		} params;

		params.srStringID = srStringID;
		params.TokenList = TokenList;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void Object::SetCustomToken( Int nTokenNum, String sToken )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SetCustomToken" );

		struct SetCustomTokenParams
		{
			Int nTokenNum; //offset = 0, size = 4
			String sToken; //offset = 4, size = 12
		} params;

		params.nTokenNum = nTokenNum;
		params.sToken = sToken;

		this->call_function( function, &params, 0 );
	}

	void Object::ClearCustomTokens()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ClearCustomTokens" );

		this->call_function( function, 0, 0 );
	}

	Object* Object::DynamicLoadDefaultResource( String sIniKey, Class* ExpectedClass )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DynamicLoadDefaultResource" );

		struct DynamicLoadDefaultResourceParams
		{
			String sIniKey; //offset = 0, size = 12
			Class* ExpectedClass; //offset = 12, size = 4
			Object* ReturnValue; //offset = 16, size = 4
		} params;

		params.sIniKey = sIniKey;
		params.ExpectedClass = ExpectedClass;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FInterpTo( Float Current, Float Target, Float DeltaTime, Float InterpSpeed )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FInterpTo" );

		struct FInterpToParams
		{
			Float Current; //offset = 0, size = 4
			Float Target; //offset = 4, size = 4
			Float DeltaTime; //offset = 8, size = 4
			Float InterpSpeed; //offset = 12, size = 4
			Float ReturnValue; //offset = 16, size = 4
		} params;

		params.Current = Current;
		params.Target = Target;
		params.DeltaTime = DeltaTime;
		params.InterpSpeed = InterpSpeed;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FPctByRange( Float Value, Float InMin, Float InMax )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FPctByRange" );

		struct FPctByRangeParams
		{
			Float Value; //offset = 0, size = 4
			Float InMin; //offset = 4, size = 4
			Float InMax; //offset = 8, size = 4
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.Value = Value;
		params.InMin = InMin;
		params.InMax = InMax;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::RandRange( Float InMin, Float InMax )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.RandRange" );

		struct RandRangeParams
		{
			Float InMin; //offset = 0, size = 4
			Float InMax; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.InMin = InMin;
		params.InMax = InMax;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FInterpEaseInOut( Float A, Float B, Float Alpha, Float Exp )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FInterpEaseInOut" );

		struct FInterpEaseInOutParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float Alpha; //offset = 8, size = 4
			Float Exp; //offset = 12, size = 4
			Float ReturnValue; //offset = 16, size = 4
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;
		params.Exp = Exp;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FInterpEaseOut( Float A, Float B, Float Alpha, Float Exp )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FInterpEaseOut" );

		struct FInterpEaseOutParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float Alpha; //offset = 8, size = 4
			Float Exp; //offset = 12, size = 4
			Float ReturnValue; //offset = 16, size = 4
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;
		params.Exp = Exp;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FInterpEaseIn( Float A, Float B, Float Alpha, Float Exp )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FInterpEaseIn" );

		struct FInterpEaseInParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float Alpha; //offset = 8, size = 4
			Float Exp; //offset = 12, size = 4
			Float ReturnValue; //offset = 16, size = 4
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;
		params.Exp = Exp;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FCubicInterp( Float P0, Float T0, Float P1, Float T1, Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FCubicInterp" );

		struct FCubicInterpParams
		{
			Float P0; //offset = 0, size = 4
			Float T0; //offset = 4, size = 4
			Float P1; //offset = 8, size = 4
			Float T1; //offset = 12, size = 4
			Float A; //offset = 16, size = 4
			Float ReturnValue; //offset = 20, size = 4
		} params;

		params.P0 = P0;
		params.T0 = T0;
		params.P1 = P1;
		params.T1 = T1;
		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Round( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Round" );

		struct RoundParams
		{
			Float A; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Lerp( Float A, Float B, Float Alpha )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Lerp" );

		struct LerpParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float Alpha; //offset = 8, size = 4
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.A = A;
		params.B = B;
		params.Alpha = Alpha;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FClamp( Float V, Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FClamp" );

		struct FClampParams
		{
			Float V; //offset = 0, size = 4
			Float A; //offset = 4, size = 4
			Float B; //offset = 8, size = 4
			Float ReturnValue; //offset = 12, size = 4
		} params;

		params.V = V;
		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FMax( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FMax" );

		struct FMaxParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FMin( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FMin" );

		struct FMinParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::FRand()
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.FRand" );

		struct FRandParams
		{
			Float ReturnValue; //offset = 0, size = 4
		} params;


		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Square( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Square" );

		struct SquareParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Sqrt( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Sqrt" );

		struct SqrtParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Loge( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Loge" );

		struct LogeParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Exp( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Exp" );

		struct ExpParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Atan( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Atan" );

		struct AtanParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Tan( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Tan" );

		struct TanParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Acos( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Acos" );

		struct AcosParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Cos( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Cos" );

		struct CosParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Asin( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Asin" );

		struct AsinParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Sin( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Sin" );

		struct SinParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Abs( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Abs" );

		struct AbsParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::SubtractEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractEqual_FloatFloat" );

		struct SubtractEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::AddEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddEqual_FloatFloat" );

		struct AddEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::DivideEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DivideEqual_FloatFloat" );

		struct DivideEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::MultiplyEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyEqual_FloatFloat" );

		struct MultiplyEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_FloatFloat" );

		struct NotEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::ComplementEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ComplementEqual_FloatFloat" );

		struct ComplementEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_FloatFloat" );

		struct EqualEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::GreaterEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GreaterEqual_FloatFloat" );

		struct GreaterEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::LessEqual_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.LessEqual_FloatFloat" );

		struct LessEqual_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::Greater_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Greater_FloatFloat" );

		struct Greater_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::Less_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Less_FloatFloat" );

		struct Less_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Subtract_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_FloatFloat" );

		struct Subtract_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Add_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Add_FloatFloat" );

		struct Add_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Percent_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Percent_FloatFloat" );

		struct Percent_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Divide_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Divide_FloatFloat" );

		struct Divide_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Multiply_FloatFloat( Float A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_FloatFloat" );

		struct Multiply_FloatFloatParams
		{
			Float A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::MultiplyMultiply_FloatFloat( Float Base, Float Exp )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyMultiply_FloatFloat" );

		struct MultiplyMultiply_FloatFloatParams
		{
			Float Base; //offset = 0, size = 4
			Float Exp; //offset = 4, size = 4
			Float ReturnValue; //offset = 8, size = 4
		} params;

		params.Base = Base;
		params.Exp = Exp;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Float Object::Subtract_PreFloat( Float A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_PreFloat" );

		struct Subtract_PreFloatParams
		{
			Float A; //offset = 0, size = 4
			Float ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	String Object::ToHex( Int A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.ToHex" );

		struct ToHexParams
		{
			Int A; //offset = 0, size = 4
			String ReturnValue; //offset = 4, size = 12
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Clamp( Int V, Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Clamp" );

		struct ClampParams
		{
			Int V; //offset = 0, size = 4
			Int A; //offset = 4, size = 4
			Int B; //offset = 8, size = 4
			Int ReturnValue; //offset = 12, size = 4
		} params;

		params.V = V;
		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Max( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Max" );

		struct MaxParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Min( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Min" );

		struct MinParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Rand( Int Max )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Rand" );

		struct RandParams
		{
			Int Max; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.Max = Max;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::SubtractSubtract_Int( Int A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractSubtract_Int" );

		struct SubtractSubtract_IntParams
		{
			Int A; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::AddAdd_Int( Int A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddAdd_Int" );

		struct AddAdd_IntParams
		{
			Int A; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::SubtractSubtract_PreInt( Int A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractSubtract_PreInt" );

		struct SubtractSubtract_PreIntParams
		{
			Int A; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::AddAdd_PreInt( Int A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddAdd_PreInt" );

		struct AddAdd_PreIntParams
		{
			Int A; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::SubtractEqual_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractEqual_IntInt" );

		struct SubtractEqual_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::AddEqual_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddEqual_IntInt" );

		struct AddEqual_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::DivideEqual_IntFloat( Int A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DivideEqual_IntFloat" );

		struct DivideEqual_IntFloatParams
		{
			Int A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::MultiplyEqual_IntFloat( Int A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyEqual_IntFloat" );

		struct MultiplyEqual_IntFloatParams
		{
			Int A; //offset = 0, size = 4
			Float B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Or_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Or_IntInt" );

		struct Or_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Xor_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Xor_IntInt" );

		struct Xor_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::And_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.And_IntInt" );

		struct And_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_IntInt" );

		struct NotEqual_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_IntInt" );

		struct EqualEqual_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::GreaterEqual_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GreaterEqual_IntInt" );

		struct GreaterEqual_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::LessEqual_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.LessEqual_IntInt" );

		struct LessEqual_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::Greater_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Greater_IntInt" );

		struct Greater_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::Less_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Less_IntInt" );

		struct Less_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::GreaterGreaterGreater_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GreaterGreaterGreater_IntInt" );

		struct GreaterGreaterGreater_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::GreaterGreater_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.GreaterGreater_IntInt" );

		struct GreaterGreater_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::LessLess_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.LessLess_IntInt" );

		struct LessLess_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Subtract_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_IntInt" );

		struct Subtract_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Add_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Add_IntInt" );

		struct Add_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Divide_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Divide_IntInt" );

		struct Divide_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Multiply_IntInt( Int A, Int B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Multiply_IntInt" );

		struct Multiply_IntIntParams
		{
			Int A; //offset = 0, size = 4
			Int B; //offset = 4, size = 4
			Int ReturnValue; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Subtract_PreInt( Int A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Subtract_PreInt" );

		struct Subtract_PreIntParams
		{
			Int A; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Object::Complement_PreInt( Int A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Complement_PreInt" );

		struct Complement_PreIntParams
		{
			Int A; //offset = 0, size = 4
			Int ReturnValue; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::SubtractSubtract_Byte( Byte A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractSubtract_Byte" );

		struct SubtractSubtract_ByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte ReturnValue; //offset = 1, size = 1
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::AddAdd_Byte( Byte A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddAdd_Byte" );

		struct AddAdd_ByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte ReturnValue; //offset = 1, size = 1
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::SubtractSubtract_PreByte( Byte A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractSubtract_PreByte" );

		struct SubtractSubtract_PreByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte ReturnValue; //offset = 1, size = 1
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::AddAdd_PreByte( Byte A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddAdd_PreByte" );

		struct AddAdd_PreByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte ReturnValue; //offset = 1, size = 1
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::SubtractEqual_ByteByte( Byte A, Byte B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.SubtractEqual_ByteByte" );

		struct SubtractEqual_ByteByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte B; //offset = 1, size = 1
			Byte ReturnValue; //offset = 2, size = 1
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::AddEqual_ByteByte( Byte A, Byte B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AddEqual_ByteByte" );

		struct AddEqual_ByteByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte B; //offset = 1, size = 1
			Byte ReturnValue; //offset = 2, size = 1
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::DivideEqual_ByteByte( Byte A, Byte B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.DivideEqual_ByteByte" );

		struct DivideEqual_ByteByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte B; //offset = 1, size = 1
			Byte ReturnValue; //offset = 2, size = 1
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::MultiplyEqual_ByteFloat( Byte A, Float B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyEqual_ByteFloat" );

		struct MultiplyEqual_ByteFloatParams
		{
			Byte A; //offset = 0, size = 1
			Float B; //offset = 4, size = 4
			Byte ReturnValue; //offset = 8, size = 1
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Byte Object::MultiplyEqual_ByteByte( Byte A, Byte B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.MultiplyEqual_ByteByte" );

		struct MultiplyEqual_ByteByteParams
		{
			Byte A; //offset = 0, size = 1
			Byte B; //offset = 1, size = 1
			Byte ReturnValue; //offset = 2, size = 1
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::OrOr_BoolBool( Bool A, Bool B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.OrOr_BoolBool" );

		struct OrOr_BoolBoolParams
		{
			Bool A: 1; //offset = 0, size = 4
			Bool B: 1; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::XorXor_BoolBool( Bool A, Bool B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.XorXor_BoolBool" );

		struct XorXor_BoolBoolParams
		{
			Bool A: 1; //offset = 0, size = 4
			Bool B: 1; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::AndAnd_BoolBool( Bool A, Bool B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.AndAnd_BoolBool" );

		struct AndAnd_BoolBoolParams
		{
			Bool A: 1; //offset = 0, size = 4
			Bool B: 1; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::NotEqual_BoolBool( Bool A, Bool B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.NotEqual_BoolBool" );

		struct NotEqual_BoolBoolParams
		{
			Bool A: 1; //offset = 0, size = 4
			Bool B: 1; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::EqualEqual_BoolBool( Bool A, Bool B )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.EqualEqual_BoolBool" );

		struct EqualEqual_BoolBoolParams
		{
			Bool A: 1; //offset = 0, size = 4
			Bool B: 1; //offset = 4, size = 4
			Bool ReturnValue: 1; //offset = 8, size = 4
		} params;

		params.A = A;
		params.B = B;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool Object::Not_PreBool( Bool A )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Object.Not_PreBool" );

		struct Not_PreBoolParams
		{
			Bool A: 1; //offset = 0, size = 4
			Bool ReturnValue: 1; //offset = 4, size = 4
		} params;

		params.A = A;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int Commandlet::Main( String Params )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.Commandlet.Main" );

		struct MainParams
		{
			String Params; //offset = 0, size = 12
			Int ReturnValue; //offset = 12, size = 4
		} params;

		params.Params = Params;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Int HelpCommandlet::Main( String Params )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.HelpCommandlet.Main" );

		struct MainParams
		{
			String Params; //offset = 0, size = 12
			Int ReturnValue; //offset = 12, size = 4
		} params;

		params.Params = Params;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void BioTelemetry::SendEventBool( Name sEventName, Bool nPayload )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioTelemetry.SendEventBool" );

		struct SendEventBoolParams
		{
			Name sEventName; //offset = 0, size = 8
			Bool nPayload: 1; //offset = 8, size = 4
		} params;

		params.sEventName = sEventName;
		params.nPayload = nPayload;

		this->call_function( function, &params, 0 );
	}

	void BioTelemetry::SendEventInt( Name sEventName, Int nPayload )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioTelemetry.SendEventInt" );

		struct SendEventIntParams
		{
			Name sEventName; //offset = 0, size = 8
			Int nPayload; //offset = 8, size = 4
		} params;

		params.sEventName = sEventName;
		params.nPayload = nPayload;

		this->call_function( function, &params, 0 );
	}

	void BioTelemetry::SendEventString( Name sEventName, String sPayload )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioTelemetry.SendEventString" );

		struct SendEventStringParams
		{
			Name sEventName; //offset = 0, size = 8
			String sPayload; //offset = 8, size = 12
		} params;

		params.sEventName = sEventName;
		params.sPayload = sPayload;

		this->call_function( function, &params, 0 );
	}

	void BioTelemetry::SendEventName( Name sEventName, Name sPayload )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioTelemetry.SendEventName" );

		struct SendEventNameParams
		{
			Name sEventName; //offset = 0, size = 8
			Name sPayload; //offset = 8, size = 8
		} params;

		params.sEventName = sEventName;
		params.sPayload = sPayload;

		this->call_function( function, &params, 0 );
	}

	void BioTelemetry::SendEvent( Name sEventName )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioTelemetry.SendEvent" );

		struct SendEventParams
		{
			Name sEventName; //offset = 0, size = 8
		} params;

		params.sEventName = sEventName;

		this->call_function( function, &params, 0 );
	}

	Bool BioBaseTokenParser::GetStringToken( Int nActionCode, String sToken )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioBaseTokenParser.GetStringToken" );

		struct GetStringTokenParams
		{
			Int nActionCode; //offset = 0, size = 4
			String sToken; //offset = 4, size = 12
			Bool ReturnValue: 1; //offset = 16, size = 4
		} params;

		params.nActionCode = nActionCode;
		params.sToken = sToken;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	Bool BioBaseSaveObject::SaveBaseObjectInfo( Object* O )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioBaseSaveObject.SaveBaseObjectInfo" );

		struct SaveBaseObjectInfoParams
		{
			Object* O; //offset = 0, size = 4
			Bool ReturnValue: 1; //offset = 4, size = 4
		} params;

		params.O = O;

		this->call_function( function, &params, 0 );

		return params.ReturnValue;
	}

	void BioBaseSaveObject::LoadObject( Object* O )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioBaseSaveObject.LoadObject" );

		struct LoadObjectParams
		{
			Object* O; //offset = 0, size = 4
		} params;

		params.O = O;

		this->call_function( function, &params, 0 );
	}

	void BioBaseSaveObject::SaveObject( Object* O )
	{
		static ufunction* function = 0;

		if ( !function )
			function = find_global_object<ufunction>( "Function Core.BioBaseSaveObject.SaveObject" );

		struct SaveObjectParams
		{
			Object* O; //offset = 0, size = 4
		} params;

		params.O = O;

		this->call_function( function, &params, 0 );
	}
}
